home *** CD-ROM | disk | FTP | other *** search
/ MacFormat 1995 January / macformat-020.iso / Shareware City / Applications / Alpha.5.96 folder / Tcl / SystemCode / latex.tcl < prev    next >
Encoding:
Text File  |  1994-09-20  |  69.6 KB  |  2 lines  |  [TEXT/ALFA]
  1. #############################################################################
  2. #############################################################################
  3. #
  4. # latex.tcl, version 2.3:  macros and bindings for LaTeX users
  5. #
  6. # -- see "LaTeX Help" and "LaTeX Key Bindings" on the Help menu
  7. # -- command summaries suitable for printing ("latex_commands.tex" 
  8. #    and "latex_keys.tex") will be found in the LaTeX folder.
  9. #
  10. #############################################################################
  11. #
  12. # version 1.1 and 1.2 (11/10/92) by Richard T. Austin (austin@eecs.umich.edu)
  13. # version 2.0--2.2 and 2.3 (9/15/94) by Tom Scavo (trscavo@syr.edu)
  14. #
  15. # If you make improvements to this file, please share them!
  16. #
  17. #############################################################################
  18. #############################################################################
  19.  
  20.  
  21. #--------------------------------------------------------------------------
  22. # Autoload procedure:
  23. #--------------------------------------------------------------------------
  24.  
  25. proc dummyTeX {} {}
  26.  
  27. #--------------------------------------------------------------------------
  28. # Other macro packages:
  29. #--------------------------------------------------------------------------
  30.  
  31. source "$HOME:Tcl:UserCode:smart.tcl"
  32.  
  33. #--------------------------------------------------------------------------
  34. # Flags and Variables:
  35. #--------------------------------------------------------------------------
  36.  
  37. set true 1
  38. set false 0
  39.  
  40. # Flags:
  41. newModeVar TeX optionIsMeta $false 1
  42. newModeVar TeX useBoxMacro $true 1
  43. newModeVar TeX useDollarSigns $false 1
  44. newModeVar TeX searchNoisily $true 1
  45. newModeVar TeX promptNoisily $true 1
  46. newModeVar TeX deleteObjectNoisily $true 1
  47. newModeVar TeX deleteEnvironmentNoisily $true 1
  48. newModeVar TeX wordWrap $true 1
  49. newModeVar TeX useStatusBar $true 1
  50.  
  51. # Variables:
  52. newModeVar TeX boxMacroName {BoxedEPSF} 0 
  53. newModeVar TeX funcExpr {\\((sub)*section|chapter)(\[.*\]|\*)?{([^{}]*)}} 0
  54. newModeVar TeX funcExprAlt {\\(section|chapter)(\[.*\]|\*)?{([^{}]*)}} 0 
  55. newModeVar TeX prefixString {% } 0
  56. newModeVar TeX wordBreak {(\\)?[a-zA-Z0-9]+} 0
  57. newModeVar TeX wordBreakPreface {([^a-zA-Z0-9\\]|.\\)} 0
  58.  
  59. #--------------------------------------------------------------------------
  60. # Mark Menu:
  61. #--------------------------------------------------------------------------
  62.  
  63. proc TeXMarkFile {} {
  64.     set end [maxPos]
  65.     set pos 0
  66.     set l {}
  67.  
  68.     # Remove all previous marks in this file?
  69.     set exp {\\((sub)*section|chapter)(\[.*\]|\*)?{([^{}]*)}}
  70.     while {![catch {search -f 1 -r 1 -m 0 -i 0 $exp $pos} res]} {
  71.         set start [lindex $res 0]
  72.         set end [lindex $res 1]
  73.         set text [getText $start $end]
  74.         if {[regexp {\{(.*)\}} $text dummy mtch]} {
  75.             set lab ""
  76.             if {[regexp {(sub)*section} $text title]} then {
  77.                 append lab $l [format "%[expr [string length $title] - 7]\s" ""]
  78.             } else {
  79.                 set l {   }
  80.             }
  81.             append lab $mtch
  82.             setNamedMark $lab [lineStart [expr $start - 1]] $start $start
  83.         }
  84.         set pos [expr $end+1]
  85.     }
  86. }
  87.  
  88. #--------------------------------------------------------------------------
  89. # Insertion routines:
  90. #--------------------------------------------------------------------------
  91.  
  92. # Returns a modified text string if the string $text is non-null, 
  93. # and the null string otherwise.  The argument 'operation' is a 
  94. # string directing 'doPrefixText' to either "insert" or "remove" 
  95. # $prefixString to/from each line of $text.  (This routine is
  96. # adapted from strings.tcl.)
  97. proc doPrefixText {operation prefixString text} {
  98.     if {$text == ""} {return ""}
  99.     set pref [quoteExpr $prefixString]
  100.     if {$operation == "insert"} then {
  101.         set trailChar ""
  102.         set textLen [string length $text]
  103.         if {[string index $text [expr $textLen-1]] == "\r"} then {
  104.             set text [string range $text 0 [expr $textLen-2]]
  105.             set trailChar "\r"
  106.         }
  107.         set str \r$prefixString
  108.         regsub -all \r $text $str text
  109.         return $prefixString$text$trailChar
  110.     } elseif {$operation == "remove"} then {
  111.         regsub -all \r$pref $text \r text
  112.         regsub ^$pref $text "" text
  113.         return $text
  114.     }
  115. }
  116.  
  117. # Shift each line of $text to the right by inserting a string of
  118. # $whitespace characters at the beginning of each line, returning
  119. # the resulting string.
  120. proc shiftTextRight {text whitespace} {
  121.     return [doPrefixText "insert" $whitespace $text]
  122. }
  123.  
  124. # Return a string of whitespace characters from the beginning 
  125. # of the line containing $pos up to the first non-whitespace 
  126. # character.
  127. proc getIndentation {pos} {
  128.     set text [getText [lineStart $pos] [nextLineStart $pos]]
  129.     regexp {^[ \t]*} $text theIndentation
  130.     return $theIndentation
  131. }
  132.  
  133. # Return an "indented carriage return" if any character preceding 
  134. # the insertion point (on the same line) is a non-whitespace 
  135. # character.  Otherwise, return the null string.
  136. proc openingCarriageReturn {} {
  137.     set pos [getPos]
  138.     set end $pos
  139.     set start [lineStart $pos]
  140.     set text [getText $start $end]
  141.     if {[isWhitespace $text]} then {
  142.         if {$start == $end} {return [getIndentation $pos]} {return ""}
  143.     } else {
  144.         return "\r[getIndentation $pos]"
  145.     }
  146. }
  147. # Return an "indented carriage return" if any character following 
  148. # the insertion point (on the same line) is a non-whitespace 
  149. # character.  Otherwise, return the null string.
  150. proc closingCarriageReturn {} {
  151.     set pos [selEnd]
  152.     if {[isSelection] && ($pos == [lineStart $pos])} then {
  153.         return "\r"
  154.     } else {
  155.         set start $pos
  156.         set end [nextLineStart $start]
  157.         set text [getText $start $end]
  158.         if {[isWhitespace $text]} then {
  159.             return ""
  160.         } else {
  161.             return "\r[getIndentation $pos]"
  162.         }
  163.     }
  164. }
  165.  
  166. # Insert an object at the insertion point. If there is a selection and the 
  167. # global variable 'deleteObjectNoisily' is false, quietly delete the selection 
  168. # first (just like 'paste'). Otherwise, prompt the user for the appropriate 
  169. # action. Returns true if the object is ultimately inserted, and false if the 
  170. # user cancels the operation. 
  171. proc insertObject {objectName} {
  172.     global deleteObjectNoisily
  173.     if {[isSelection]} then {
  174.         if {$deleteObjectNoisily} then {
  175.             case [askyesno -c "Delete selection?"] in {
  176.                 "yes" {deleteText [getPos] [selEnd]}
  177.                 "no" {backwardChar}
  178.                 "cancel" {return 0}
  179.             }
  180.         } else {
  181.             deleteText [getPos] [selEnd]
  182.         }
  183.     }
  184.     insertText $objectName
  185.     return 1
  186. }
  187.  
  188. # Insert an object at the insertion point. If there is a selection, wrap 
  189. # it inside the parameters $left and $right. Returns true if there is a 
  190. # selection (in which case it will wrap), and false otherwise. 
  191. proc wrapObject {left right} {
  192.     set currentPos [getPos]
  193.     set selected [isSelection]
  194.     if {$selected} then {
  195.         replaceText $currentPos [selEnd] $left [getSelect] $right
  196.     } else {
  197.         insertText $left "•" $right
  198.     }
  199.     goto $currentPos
  200.     nextTabStop
  201.     return $selected
  202. }
  203.  
  204. # Builds and returns a LaTeX environment, that is, a \begin...\end 
  205. # pair, given the name of the environment, an argument string, 
  206. # and the environment body.  The body should be passed to this 
  207. # procedure fully formatted, including indentation.
  208. proc buildEnvironment {envName envArg envBody trailingComment} {
  209.     set indent [getIndentation [getPos]]
  210.     set envStr [openingCarriageReturn]
  211.     append envStr "\\begin{" $envName "}"
  212.     append envStr $envArg "\r"
  213.     append envStr $envBody
  214.     append envStr $indent "\\end{" $envName "}$trailingComment"
  215.     append envStr [closingCarriageReturn]
  216.     return $envStr
  217. }
  218.  
  219. # Inserts a LaTeX environment with the specified name, argument, 
  220. # and body at the insertion point.  Positions the cursor at the 
  221. # beginning of the environment, leaving any subsequent action to the 
  222. # calling procedure.  Deletes the current selection quietly if the 
  223. # global variable 'deleteEnvironmentNoisily' is false; otherwise 
  224. # the user is prompted for directions.  Returns true if the 
  225. # environment is ultimately inserted, and false if the user cancels 
  226. # the operation.
  227. proc insertEnvironment {envName envArg envBody} {
  228.     global deleteEnvironmentNoisily
  229.     if {[isSelection]} then {
  230.         if {$deleteEnvironmentNoisily} then {
  231.             case [askyesno -c "Delete selection?"] in {
  232.                 "yes" {}
  233.                 "no" {backwardChar}
  234.                 "cancel" {return 0}
  235.             }
  236.         }
  237.     }
  238.     set start [getPos]
  239.     set end [selEnd]
  240.     set body [shiftTextRight $envBody [getIndentation $start]]
  241.     replaceText $start $end [buildEnvironment $envName $envArg $body "•"]
  242.     goto $start
  243.     return 1
  244. }
  245.  
  246. # Inserts an environment with the given name, argument, and body at 
  247. # the insertion point.  Positions the cursor at the beginning of 
  248. # the environment, leaving any subsequent action to the calling 
  249. # procedure.  If there is currently a selection, cut and paste it 
  250. # into the body of the new environment, maintaining proper 
  251. # indentation; otherwise, insert a tab stop into the body of the
  252. # environment.  Returns true if there is a selection, and false 
  253. # otherwise.
  254. proc wrapEnvironment {envName envArg envBody} {
  255.     set start [getPos]
  256.     set end [selEnd]
  257.     set indent [getIndentation $start]
  258.     if {[isSelection]} then {
  259.         set text [getSelect]
  260.         set textLen [string length $text]
  261.         if {[string index $text [expr $textLen-1]] != "\r"} then {
  262.             append text "\r"
  263.         }
  264.         if {$start == [lineStart $start]} then {
  265.             set body [shiftTextRight $text \t]
  266.         } else {
  267.             set body "$indent[shiftTextRight $text \t]"
  268.         }
  269.         append body [shiftTextRight $envBody $indent]
  270.         set environment [buildEnvironment $envName $envArg $body "•"]
  271.         set returnFlag 1
  272.     } else {
  273.         append body "$indent\t•\r" [shiftTextRight $envBody $indent]
  274.         set environment [buildEnvironment $envName $envArg $body "•"]
  275.         set returnFlag 0
  276.     }
  277.     replaceText $start $end $environment
  278.     goto $start
  279.     return $returnFlag
  280. }
  281.  
  282. # A generic call to 'wrapEnvironment' used throughout latex.tcl:
  283. proc doWrapEnvironment {envName} {
  284.     if {[wrapEnvironment $envName "" ""]} then {
  285.         set msgText "selection wrapped"
  286.     } else {
  287.         set msgText "enter body of $envName environment"
  288.     }
  289.     nextTabStop
  290.     message $msgText
  291. }
  292.  
  293. # Inserts a structured document template at the insertion point.  
  294. # Three arguments are required:  the class name of the document, a 
  295. # preamble string, and a string containing the body of the document.  
  296. # If the preamble is null, a generic \usepackage statement is 
  297. # inserted; otherwise, the preamble is inserted as is.  This routine 
  298. # does absolutely no error-checking (this is totally left up to the 
  299. # calling procedure) and returns nothing.
  300. proc insertDocument {className preamble docBody} {
  301.     set docStr "\\documentclass\[•\]{$className}\r"
  302.     if {$preamble == ""} then {
  303.         append docStr "\\usepackage{•}\r\r•\r\r"
  304.     } else {
  305.         append docStr $preamble
  306.     }
  307.     append docStr [buildEnvironment "document" "" $docBody "\r"]
  308.     set start [getPos]
  309.     set end [selEnd]
  310.     replaceText $start $end $docStr
  311.     goto $start
  312.     return
  313. }
  314.  
  315. # Inserts a document template at the insertion point given the 
  316. # class name of the document to be inserted.  If ALL of the current
  317. # document is selected, then the routine wraps the text inside a
  318. # generic document template.  If the file is empty, a bullet is 
  319. # inserted in place of the document body.  If neither of these 
  320. # conditions is true, an alert is displayed, and no action is taken.  
  321. # Returns true if wrapping occurs, and false otherwise.
  322. proc wrapDocument {className} {
  323.     if {[isEmptyFile]} then {
  324.         append body "\r•\r\r"
  325.         set returnFlag 0
  326.     } else {
  327.         if {[isDocumentSelected]} then {
  328.             set text [getSelect]
  329.             append body "\r$text\r"
  330.             set returnFlag 1
  331.         } else {
  332.             alertnote "nonempty file:  delete text or \'Select All\'\
  333.                 from the Edit menu"
  334.             return 0
  335.         }
  336.     }
  337.     set docStr "\\documentclass\[•\]{$className}\r"
  338.     append docStr "\\usepackage{•}\r\r•\r\r"
  339.     append docStr [buildEnvironment "document" "" $body "\r"]
  340.     set start [getPos]
  341.     set end [selEnd]
  342.     replaceText $start $end $docStr
  343.     goto $start
  344.     nextTabStop
  345.     message "enter style (or leave blank)"
  346.     return $returnFlag
  347. }
  348.  
  349. #--------------------------------------------------------------------------
  350. # Misc:
  351. #--------------------------------------------------------------------------
  352.  
  353. # Checks to see if there's a current selection.
  354. proc isSelection {} {
  355.     return [string length [getSelect]]
  356. }
  357.  
  358. # Checks to see if the current window is empty, sans whitespace.
  359. proc isEmptyFile {} {
  360.     return [isWhitespace [getText 0 [maxPos]]]
  361. }
  362.  
  363. # If there is a selection, make sure it's uppercase.  Otherwise, 
  364. # check to see if the character after the insertion point is uppercase.
  365. proc isUppercase {} {
  366.     if {[isSelection]} then {
  367.         set text [getSelect]
  368.     } else {
  369.         set text [lookAt [getPos]]
  370.     }
  371.     return [expr {[string toupper $text] == $text}]
  372. }
  373.  
  374. # Returns true if the entire window is selected, and false otherwise.
  375. proc isDocumentSelected {} {
  376.     return [expr {([getPos] == 0) && ([selEnd] == [maxPos])}]
  377. }
  378.  
  379. # Takes any string and tests whether or not that string contains all 
  380. # whitespace characters.  Carriage returns are considered whitespace, 
  381. # as are spaces and tabs.  Also returns true for the null string.
  382. proc isWhitespace {anyString} {
  383.     set len [string length $anyString]
  384.     for {set i 0} {$i < $len} {incr i} {
  385.         set c [string index $anyString $i]
  386.         if {($c != "\ ") && ($c != "\t") && ($c != "\r")} then {return 0}
  387.     }
  388.     return 1
  389. }
  390.  
  391. # Select the line containing the insertion point.
  392. proc lineSelect {} {
  393.     goto [lineStart [getPos]]
  394.     nextLineSelect
  395. }
  396.  
  397. # Check to see if the LaTeX symbol package has been loaded; if not, ask 
  398. # the user for directions.  Returns false if the package is not loaded
  399. # AND the user cancels the operation; otherwise, returns true.
  400. proc isSymbolPackageLoaded {} {
  401.     global searchNoisily
  402.     set begPos [getPos]
  403.     set endPos [selEnd]
  404.     set searchString {\\usepackage\{.*latexsym.*\}}
  405.     set searchResult [search -n -f 0 -m 0 -i 1 -r 1 $searchString $begPos]
  406.     if {[llength $searchResult] == 0} then {
  407.         case [askyesno -c "Insert the LaTeX symbol package?"] in {
  408.             "yes" {
  409.                 set searchString {\\documentclass(\[.*\])?\{.*\}}
  410.                 set searchResult [search -n -f 0 -m 0 -i 1 -r 1 $searchString $begPos]
  411.                 if {[llength $searchResult] == 0} then {
  412.                     set returnVal 0
  413.                     if {$searchNoisily} {beep}
  414.                     message "can't find \\documentclass"
  415.                 } else {
  416.                     goto [lindex $searchResult 1]
  417.                     set txt "\r\\usepackage\{latexsym\}"
  418.                     set offset [string length $txt]
  419.                     set begPos [expr $begPos + $offset]
  420.                     set endPos [expr $endPos + $offset]
  421.                     insertText $txt
  422.                     set returnVal 1
  423.                 }
  424.             }
  425.             "no" {set returnVal 1}
  426.             "cancel" {set returnVal 0}
  427.         }
  428.     } else {
  429.         set returnVal 1
  430.     }
  431.     select $begPos $endPos
  432.     return $returnVal
  433. }
  434.  
  435.  
  436. #############################################################################
  437. # 
  438. # Basic Commands
  439. #
  440. #############################################################################
  441.  
  442. proc typeset {} {
  443.     global latexPath
  444.     
  445.     # Initialization:
  446.     set isOzTeX 0
  447.     set isTextures 0
  448.     set isCMacTeX 0
  449.     
  450.     set currentWin [lindex [winNames -f] 0]
  451.     
  452.     # Check if a LaTeX app is running.  If not, open the app named in 
  453.     # $latexPath (if defined) or have the user select an app via a
  454.     # standard file dialog.
  455.     set appName [checkRunningL LaTeX {OTEX *TEX *XeT} latexPath]
  456.     
  457.     if {[string match {OzTeX*} $appName]} {
  458.         set isOzTeX 1
  459.     } elseif {[string match {Textures*} $appName]} {
  460.         set isTextures 1
  461.     } elseif {[string match {*tex} $appName]} {
  462.         set isCMacTeX 1
  463.     } else {
  464.         alertnote "Sorry, I don't know how to talk to \"$appName\"."
  465.         return
  466.     }
  467.     if {[winInfo dirty]} {
  468.         case [askyesno -c "Save \"$currentWin\"?"] in {
  469.             "yes" {save}
  470.             "no" {}
  471.             "cancel" {return}
  472.         }
  473.     }
  474.     switchTo $appName
  475.     if {$isOzTeX} {
  476.         sendOpenEvent -n $appName $currentWin
  477.     } elseif {$isTextures} {
  478.         sendOpenEvent -n $appName $currentWin
  479.     } elseif {$isCMacTeX} {
  480.         dosc -n $name -k 'aevt' -e 'odoc' -r -f $currentWin
  481.     }
  482. }
  483. # Slightly modified version of 'checkRunning' that looks for any of a
  484. # list of running apps.  (Courtesy of Tom Pollard)
  485. proc checkRunningL {prompt sigs path} {
  486.     global $path
  487.     foreach sig $sigs {
  488.         foreach proc [processes] {
  489.             if {[lindex $proc 1] == $sig} {
  490.                 return [lindex $proc 0]
  491.             }
  492.         }
  493.     }
  494.     if {![info exists $path] || ![file exists [set $path]]} {
  495.         if {[addAppPath $prompt $path]} return
  496.     }
  497.     if {[catch {getFileSig [set $path]}]} {
  498.         if {[addAppPath $prompt $path]} return
  499.     }
  500.     set sig [getFileSig [set $path]]
  501.     if {[catch {launch -f [set $path]}]} {
  502.         error "Problem with launching file (out of memory?)"
  503.     }
  504.     return [file tail [set $path]]
  505. #    return [checkRunning $name $sig $path]
  506. }
  507.  
  508.  
  509. #--------------------------------------------------------------------------
  510. # Goto:
  511. #--------------------------------------------------------------------------
  512.  
  513. # Switch to (but don't execute) any of the following applications.
  514. proc latex {} {
  515.     global latexPath
  516.     set sig ""
  517.     catch {string trim [lindex [getfinfo $latexPath] 1] '} sig
  518.     set name [checkRunning latex $sig latexPath]
  519.     if {![string length $name]} return
  520.     switchTo $name
  521. }
  522. proc bibtex {} {
  523.     global bibtexPath
  524.     set name [checkRunning BibTeX BIBt bibtexPath]
  525.     if {![string length $name]} return
  526.     switchTo $name
  527. }
  528. proc makeindex {} {
  529.     global makeindexPath
  530.     set name [checkRunning MakeIndex Midx makeindexPath]
  531.     if {![string length $name]} return
  532.     switchTo $name
  533. }
  534.  
  535. proc nextSection {} {
  536.     global searchNoisily funcExprAlt
  537.     set searchString $funcExprAlt
  538.     if {[isSelection]} then {
  539.         set searchPos [expr [getPos]+1]
  540.     } else {
  541.         set searchPos [getPos]
  542.     }
  543.     set searchResult [search -f 1 -r 1 -n $searchString $searchPos]
  544.     if {[string length $searchResult]} {
  545.         select [lindex $searchResult 0] [lindex $searchResult 1]
  546.     } else {
  547.         if {$searchNoisily} {beep}
  548.         message "next $funcExprAlt not found"
  549.     }
  550. }
  551. proc prevSection {} {
  552.     global searchNoisily funcExprAlt
  553.     set searchString $funcExprAlt
  554.     set searchResult [search -f 0 -r 1 -n $searchString [expr [getPos]-1]]
  555.     if {[string length $searchResult]} {
  556.         select [lindex $searchResult 0] [lindex $searchResult 1]
  557.     } else {
  558.         if {$searchNoisily} {beep}
  559.         message "previous $funcExprAlt not found"
  560.     }
  561. }
  562. proc nextSubsection {} {
  563.     global searchNoisily funcExpr
  564.     set searchString $funcExpr
  565.     if {[isSelection]} then {
  566.         set searchPos [expr [getPos]+1]
  567.     } else {
  568.         set searchPos [getPos]
  569.     }
  570.     set searchResult [search -f 1 -r 1 -n $searchString $searchPos]
  571.     if {[string length $searchResult]} {
  572.         select [lindex $searchResult 0] [lindex $searchResult 1]
  573.     } else {
  574.         if {$searchNoisily} {beep}
  575.         message "next $funcExpr not found"
  576.     }
  577. }
  578. proc prevSubsection {} {
  579.     global searchNoisily funcExpr
  580.     set searchString $funcExpr
  581.     set searchResult [search -f 0 -r 1 -n $searchString [expr [getPos]-1]]
  582.     if {[string length $searchResult]} {
  583.         select [lindex $searchResult 0] [lindex $searchResult 1]
  584.     } else {
  585.         if {$searchNoisily} {beep}
  586.         message "previous $funcExpr not found"
  587.     }
  588. }
  589.  
  590. proc gotoTabStop {directionIndicator} {
  591.     set searchResult [search -n -f $directionIndicator -m 0 -i 1 -r 0 {•} [getPos]]
  592.     if {[llength $searchResult] == 0} then {
  593.         return 0
  594.     } else {
  595.         goto [lindex $searchResult 0]
  596.         return 1
  597.     }
  598. }
  599. proc nextTabStop {} {
  600.     global searchNoisily
  601.     set forward 1
  602.     if {[gotoTabStop $forward]} then {
  603.         deleteChar
  604.     } else {
  605.         if {$searchNoisily} {beep}
  606.         message "tab stop not found"
  607.     }
  608. }
  609. proc prevTabStop {} {
  610.     global searchNoisily
  611.     set forward 0
  612.     if {[gotoTabStop $forward]} then {
  613.         deleteChar
  614.     } else {
  615.         if {$searchNoisily} {beep}
  616.         message "tab stop not found"
  617.     }
  618. }
  619. proc nthTabStop {numTabStops} {
  620.     global searchNoisily promptNoisily useStatusBar
  621.     if {$numTabStops == 0} then {
  622.         if {$promptNoisily && $useStatusBar} {beep}
  623.         catch {sPrompt "How many tab stops?" "3"} numTabStops
  624.         if {$numTabStops == "cancel"} then {
  625.             return
  626.         }
  627.     }
  628.     set currentPos [getPos]
  629.     if {$numTabStops > 0} {set forward 1} {set forward 0}
  630.     set maxits [expr abs($numTabStops)]
  631.     if {![gotoTabStop $forward]} then {
  632.         if {$searchNoisily} {beep}
  633.         message "tab stop not found"
  634.         goto $currentPos
  635.         return
  636.     }
  637.     for {set i 1} {$i < $maxits} {incr i} {
  638.         if {$forward} {forwardChar} {backwardChar}
  639.         if {![gotoTabStop $forward]} then {
  640.             if {$searchNoisily} {beep}
  641.             message "tab stop not found"
  642.             goto $currentPos
  643.             return
  644.         }
  645.     }
  646.     deleteChar
  647. }
  648.  
  649. #--------------------------------------------------------------------------
  650. # Utilities:
  651. #--------------------------------------------------------------------------
  652.  
  653. proc clearTabStops {} {
  654.     global searchNoisily
  655.     message "working..."
  656.     set messageString "selection"
  657.     if {[set start [getPos]] == [set end [selEnd]]} {
  658.         set messageString "document"
  659.         set start 0
  660.         set end [maxPos]
  661.     }
  662.     set text [getText $start $end]
  663.     if {[regsub -all {•} $text {} text]} then {
  664.         replaceText $start $end $text
  665.         set end [getPos]
  666.         select $start $end
  667.         message "tab stops removed from $messageString"
  668.     } else {
  669.         if {$searchNoisily} {beep}
  670.         message "no tab stops found in $messageString"
  671.     }
  672. }
  673.  
  674. proc convertDollarSigns {} {
  675.     global searchNoisily
  676.     message "working..."
  677.     set messageString "selection"
  678.     if {[set start [getPos]] == [set end [selEnd]]} {
  679.         set messageString "document"
  680.         set start 0
  681.         set end [maxPos]
  682.     }
  683.     set text [getText $start $end]
  684.     # Convert all displaymath mode:
  685.     set convert1 [regsub -all {\$\$([^$]*)\$\$} $text {\\[\1\\]} text]
  686.     # Convert all math mode:
  687.     set convert2 [regsub -all {\$([^$]*)\$} $text {\\(\1\\)} text]
  688.     if {$convert1 || $convert2} then {
  689.         replaceText $start $end $text
  690.         message "$messageString converted to LaTeX math mode format"
  691.     } else {
  692.         if {$searchNoisily} {beep}
  693.         message "no dollar signs found in $messageString"
  694.     }
  695. }
  696.  
  697. proc loadSymbolPackage {} {
  698.     global searchNoisily
  699.     set begPos [getPos]
  700.     set endPos [selEnd]
  701.     set searchString {\\usepackage\{.*latexsym.*\}}
  702.     set searchResult [search -n -f 1 -m 0 -i 1 -r 1 $searchString 0]
  703.     if {[llength $searchResult] == 0} then {
  704.         set searchString {\\documentclass(\[.*\])?\{.*\}}
  705.         set searchResult [search -n -f 1 -m 0 -i 1 -r 1 $searchString 0]
  706.         if {[llength $searchResult] == 0} then {
  707.             if {$searchNoisily} {beep}
  708.             message "can't find \\documentclass"
  709.         } else {
  710.             goto [lindex $searchResult 1]
  711.             set txt "\r\\usepackage\{latexsym\}"
  712.             set offset [string length $txt]
  713.             set begPos [expr $begPos + $offset]
  714.             set endPos [expr $endPos + $offset]
  715.             insertText $txt
  716.         }
  717.     } else {
  718.         if {$searchNoisily} {beep}
  719.         select $begPos $endPos
  720.         message "symbol package already loaded"
  721.     }
  722. }
  723.  
  724.  
  725. #############################################################################
  726. # 
  727. # Paragraph Mode Macros
  728. #
  729. #############################################################################
  730.  
  731. #--------------------------------------------------------------------------
  732. # Documents:
  733. #--------------------------------------------------------------------------
  734.  
  735. proc letter {} {
  736.     set    preamble "\r\\address\{%\r"
  737.     append preamble "    •    \\\\    % insert your name here\r"
  738.     append preamble "    •    \\\\    % insert your address here\r"
  739.     append preamble "    •    \\\\    % insert more address here\r"
  740.     append preamble "    •          % insert city-state-zip here\r"
  741.     append preamble "\}\r\r"
  742.     append preamble "\\date\{•\}  % optional\r"
  743.     append preamble "\\signature\{•\}\r\r"
  744.     set    body "\r\\begin\{letter\}\{%\r"
  745.     append body "    •    \\\\    % insert addressee's name here\r"
  746.     append body "    •    \\\\    % insert addressee's address here\r"
  747.     append body "    •    \\\\    % insert more address here\r"
  748.     append body "    •          % insert addressee's city-state-zip here\r"
  749.     append body "\}\r\r"
  750.     append body "\\opening\{Dear •,\}\r\r"
  751.     if {[isEmptyFile]} then {
  752.         append body "% BODY OF LETTER\r"
  753.         append body "•\r\r"
  754.     } else {
  755.         if {[isDocumentSelected]} then {
  756.             set text [getSelect]
  757. #             deleteText 0 [maxPos]
  758.             append body "$text\r"
  759.         } else {
  760.             alertnote "nonempty file:  delete text or \'Select All\'\
  761.                 from the Edit menu"
  762.             return
  763.         }
  764.     }
  765.     append body "\\closing\{Sincerely,\}\r\r"
  766.     append body "\\encl\{•\}\r"
  767.     append body "\\cc\{•\}\r\r"
  768.     append body "\\end\{letter\}\r\r"
  769.     insertDocument "letter" $preamble $body
  770.     nextTabStop
  771.     message "enter style (or leave blank)"
  772. }
  773. proc article {} {
  774.     wrapDocument "article"
  775. }
  776. proc report {} {
  777.     wrapDocument "report"
  778. }
  779. proc book {} {
  780.     wrapDocument "book"
  781. }
  782. proc slides {} {
  783.     wrapDocument "slides"
  784. }
  785. proc custom {} {
  786.     catch {prompt "What documentclass?" "article"} documentType
  787.     if {$documentType != "cancel"} then {
  788.         wrapDocument "$documentType" 
  789.     }
  790. }
  791.  
  792. proc getStyle {} {
  793.     catch {prompt "Choose a style:" "11pt" "" "11pt" "12pt" "titlepage" \
  794.                   "twocolumn" "twoside" "a4paper" "leqno" "fleqn"} styleName
  795.     if {$styleName != "cancel"} then {
  796.         return $styleName
  797.     } else {
  798.         return ""
  799.     }
  800. }
  801. proc insertStyle {style} {
  802.     global searchNoisily
  803.     set searchString {\\documentclass}
  804.     set searchResult [search -n -f 1 -m 0 -i 1 -r 1 $searchString 0]
  805.     if {[llength $searchResult] == 0} then {
  806.         if {$searchNoisily} {beep}
  807.         message "can\'t find \\documentclass"
  808.     } else {
  809.         set nextCharPos [lindex $searchResult 1]
  810.         goto $nextCharPos
  811.         set nextChar [lookAt $nextCharPos]
  812.         if {$nextChar == "\["} then {
  813.             forwardChar
  814.             insertText $style
  815.             if {[lookAt [getPos]] != "\]"} then {
  816.                 insertText ","
  817.             }
  818.         } elseif {$nextChar == "\{"} then {
  819.             insertText "\[$style\]"
  820.         } else {
  821.             alertnote "unrecognizable \\documentclass statement"
  822.         }
  823.     }
  824. }
  825. proc styles {} {
  826.     set style [getStyle]
  827.     if {$style != ""} then {
  828.         insertStyle $style
  829.     }
  830. }
  831. proc getPackage {} {
  832.     catch {prompt "Choose a package:" "latexsym" "" "amstex" "babel" \
  833.                   "color" "graphics" "ifthen" "latexsym" "makeidx" \
  834.                   "showidx"} packageName
  835.     if {$packageName != "cancel"} then {
  836.         return $packageName
  837.     } else {
  838.         return ""
  839.     }
  840. }
  841. proc insertPackage {package} {
  842.     global searchNoisily
  843.     set searchString {\\documentclass(\[.*\])?\{.*\}}
  844.     set searchResult [search -n -f 1 -m 0 -i 1 -r 1 $searchString 0]
  845.     if {[llength $searchResult] == 0} then {
  846.         if {$searchNoisily} {beep}
  847.         message "can\'t find \\documentclass"
  848.     } else {
  849.         goto [lindex $searchResult 1]
  850.         insertText "\r\\usepackage\{$package\}"
  851.     }
  852. }
  853. proc packages {} {
  854.     set package [getPackage]
  855.     if {$package != ""} then {
  856.         insertPackage $package
  857.     }
  858. }
  859. proc filecontents {} {
  860.     global searchNoisily
  861.     set searchString {\\documentclass}
  862.     set searchResult [search -n -f 1 -m 0 -i 1 -r 1 $searchString 0]
  863.     if {[llength $searchResult] == 0} then {
  864.         if {$searchNoisily} {beep}
  865.         message "can\'t find \\documentclass"
  866.         return
  867.     } else {
  868.         set prompt "File to be included:"
  869.         if {[catch {getfile $prompt} path]} then {
  870.             return
  871.         } else {
  872.             set fd [open $path]
  873.             set text [read $fd]
  874.             close $fd
  875.             regsub -all {
  876. } $text \r text
  877.             goto 0
  878.             set envName "filecontents"
  879.             set envArg "{[file tail $path]}"
  880.             replaceText 0 0 [buildEnvironment $envName $envArg "$text\r" "\r\r"]
  881.             goto 0
  882.             message "file included"
  883.         }
  884.     }
  885. }
  886.  
  887. #--------------------------------------------------------------------------
  888. # Page Layout:
  889. #--------------------------------------------------------------------------
  890.  
  891. proc maketitle {} {
  892.     global searchNoisily
  893.     set searchString {\\document(class|style)(\[.*\])?\{.*\}}
  894.     set searchResult [search -n -f 1 -m 0 -i 1 -r 1 $searchString 0]
  895.     if {[llength $searchResult] == 0} then {
  896.         if {$searchNoisily} {beep}
  897.         message "can\'t find \\documentclass or \\documentstyle"
  898.     } else {
  899.         set searchPos [lindex $searchResult 1]
  900.         set searchString {\\begin\{document\}}
  901.         set searchResult [search -n -f 1 -m 0 -i 1 -r 1 $searchString $searchPos]
  902.         if {[llength $searchResult] == 0} then {
  903.             if {$searchNoisily} {beep}
  904.             message "can\'t find \\begin\{document\}"
  905.         } else {
  906.             goto [lindex $searchResult 1]
  907.             set currentPos [getPos]
  908.             set txt "\r\r% Definition of title page:"
  909.             append txt "\r\\title\{"
  910.             append txt "\r\t•\r\}"
  911.             append txt "\r\\author\{"
  912.             append txt "\r\t•\t% insert author(s) here"
  913.             append txt "\r\}"
  914.             append txt "\r\\date\{•\}\t% optional"
  915.             append txt "\r\r\\maketitle"
  916.             insertText $txt
  917.             goto $currentPos
  918.             nextTabStop
  919.             message "insert title"
  920.         }
  921.     }
  922. }
  923. proc abstract {} { doWrapEnvironment "abstract" }
  924. proc titlepage {} { doWrapEnvironment "titlepage" }
  925. proc getPagestyle {} {
  926.     catch {prompt "Choose a pagestyle:" "plain" "" "plain" "empty" \
  927.                   "headings" "myheadings"} pagestyleName
  928.     if {$pagestyleName != "cancel"} then {
  929.         return $pagestyleName
  930.     } else {
  931.         return ""
  932.     }
  933. }
  934. proc pagestyle {} {
  935.     set pagestyleName [getPagestyle]
  936.     if {$pagestyleName != ""} then {
  937.         openingCarriageReturn
  938.         insertObject "\\pagestyle\{$pagestyleName\}"
  939.         closingCarriageReturn
  940.     }
  941. }
  942. proc thispagestyle {} {
  943.     set pagestyleName [getPagestyle]
  944.     if {$pagestyleName != ""} then {
  945.         openingCarriageReturn
  946.         insertObject "\\thispagestyle\{$pagestyleName\}"
  947.         closingCarriageReturn
  948.     }
  949. }
  950. proc getPagenumberingStyle {} {
  951.     catch {prompt "Choose a pagenumbering style:" "arabic" "" "arabic" \
  952.                   "roman" "Roman" "alph" "Alph"} pagenumberingStyle
  953.     if {$pagenumberingStyle != "cancel"} then {
  954.         return $pagenumberingStyle
  955.     } else {
  956.         return ""
  957.     }
  958. }
  959. proc pagenumbering {} {
  960.     set pagenumberingStyle [getPagenumberingStyle]
  961.     if {$pagenumberingStyle != ""} then {
  962.         openingCarriageReturn
  963.         insertObject "\\pagenumbering\{$pagenumberingStyle\}"
  964.         closingCarriageReturn
  965.     }
  966. }
  967. proc twocolumn {} {
  968.     openingCarriageReturn
  969.     insertObject "\\twocolumn"
  970.     closingCarriageReturn
  971. }
  972. proc onecolumn {} {
  973.     openingCarriageReturn
  974.     insertObject "\\onecolumn"
  975.     closingCarriageReturn
  976. }
  977.  
  978. #--------------------------------------------------------------------------
  979. # Sectioning:
  980. #--------------------------------------------------------------------------
  981.  
  982. proc part {} {
  983.     if {[wrapObject "\\part{" "}•"]} then {
  984.         message "don't forget the label"
  985.     } else {
  986.         message "type the part name and don't forget the label"
  987.     }
  988. }
  989. proc chapter {} {
  990.     if {[wrapObject "\\chapter{" "}•"]} then {
  991.         message "don't forget the label"
  992.     } else {
  993.         message "type the chapter name and don't forget the label"
  994.     }
  995. }
  996. proc section {} {
  997.     if {[wrapObject "\\section{" "}•"]} then {
  998.         message "don't forget the label"
  999.     } else {
  1000.         message "type the section name and don't forget the label"
  1001.     }
  1002. }
  1003. proc subsection {} {
  1004.     if {[wrapObject "\\subsection{" "}•"]} then {
  1005.         message "don't forget the label"
  1006.     } else {
  1007.         message "type the subsection name and don't forget the label"
  1008.     }
  1009. }
  1010. proc subsubsection {} {
  1011.     if {[wrapObject "\\subsubsection{" "}•"]} then {
  1012.         message "don't forget the label"
  1013.     } else {
  1014.         message "type the subsubsection name and don't forget the label"
  1015.     }
  1016. }
  1017. proc paragraph {} {
  1018.     if {[wrapObject "\\paragraph{" "}•"]} then {
  1019.         message "don't forget the label"
  1020.     } else {
  1021.         message "type the paragraph name and don't forget the label"
  1022.     }
  1023. }
  1024. proc subparagraph {} {
  1025.     if {[wrapObject "\\subparagraph{" "}•"]} then {
  1026.         message "don't forget the label"
  1027.     } else {
  1028.         message "type the subparagraph name and don't forget the label"
  1029.     }
  1030. }
  1031. proc appendix {} {insertObject "\\appendix"}
  1032.  
  1033. #--------------------------------------------------------------------------
  1034. # Text Style:
  1035. #--------------------------------------------------------------------------
  1036.  
  1037. proc emph {} {
  1038.     if {[wrapObject "\\emph{" "}•"]} then {
  1039.         message "selected text is emphasized"
  1040.     } else {
  1041.         message "enter text to be emphasized"
  1042.     }
  1043. }
  1044. proc textup {} {
  1045.     if {[wrapObject "\\textup{" "}•"]} then {
  1046.         message "selected text has upright shape"
  1047.     } else {
  1048.         message "enter text to have upright shape"
  1049.     }
  1050. }
  1051. proc textit {} {
  1052.     if {[wrapObject "\\textit{" "}•"]} then {
  1053.         message "selected text has italic shape"
  1054.     } else {
  1055.         message "enter text to have italic shape"
  1056.     }
  1057. }
  1058. proc textsl {} {
  1059.     if {[wrapObject "\\textsl{" "}•"]} then {
  1060.         message "selected text has slanted shape"
  1061.     } else {
  1062.         message "enter text to have slanted shape"
  1063.     }
  1064. }
  1065. proc textsc {} {
  1066.     if {[wrapObject "\\textsc{" "}•"]} then {
  1067.         message "selected text has small caps shape"
  1068.     } else {
  1069.         message "enter text to have small caps shape"
  1070.     }
  1071. }
  1072. proc textmd {} {
  1073.     if {[wrapObject "\\textmd{" "}•"]} then {
  1074.         message "selected text has been set in medium series"
  1075.     } else {
  1076.         message "enter text to be set in medium series"
  1077.     }
  1078. }
  1079. proc textbf {} {
  1080.     if {[wrapObject "\\textbf{" "}•"]} then {
  1081.         message "selected text has been set in bold series"
  1082.     } else {
  1083.         message "enter text to be set in bold series"
  1084.     }
  1085. }
  1086. proc textrm {} {
  1087.     if {[wrapObject "\\textrm{" "}•"]} then {
  1088.         message "selected text has been set with roman family"
  1089.     } else {
  1090.         message "enter text to be set using roman family"
  1091.     }
  1092. }
  1093. proc textsf {} {
  1094.     if {[wrapObject "\\textsf{" "}•"]} then {
  1095.         message "selected text has been set with sans serif family"
  1096.     } else {
  1097.         message "enter text to be set using sans serif family"
  1098.     }
  1099. }
  1100. proc texttt {} {
  1101.     if {[wrapObject "\\texttt{" "}•"]} then {
  1102.         message "selected text has been set with typewriter family"
  1103.     } else {
  1104.         message "enter text to be set using typewriter family"
  1105.     }
  1106. }
  1107. proc textnormal {} {
  1108.     if {[wrapObject "\\textnormal{" "}•"]} then {
  1109.         message "selected text has been set with normal style"
  1110.     } else {
  1111.         message "enter text to be set using normal style"
  1112.     }
  1113. }
  1114.  
  1115. #--------------------------------------------------------------------------
  1116. # Text Size:
  1117. #--------------------------------------------------------------------------
  1118.  
  1119. proc tiny {} {
  1120.     if {[wrapObject "{\\tiny " "}•"]} then {
  1121.         message "tiny text set"
  1122.     } else {
  1123.         message "enter tiny text"
  1124.     }
  1125. }
  1126. proc scriptsize {} {
  1127.     if {[wrapObject "{\\scriptsize " "}•"]} then {
  1128.         message "scriptsize text set"
  1129.     } else {
  1130.         message "enter scriptsize text"
  1131.     }
  1132. }
  1133. proc footnotesize {} {
  1134.     if {[wrapObject "{\\footnotesize " "}•"]} then {
  1135.         message "footnotesize text set"
  1136.     } else {
  1137.         message "enter footnotesize text"
  1138.     }
  1139. }
  1140. proc small {} {
  1141.     if {[wrapObject "{\\small " "}•"]} then {
  1142.         message "small text set"
  1143.     } else {
  1144.         message "enter small text"
  1145.     }
  1146. }
  1147. proc normalsize {} {
  1148.     if {[wrapObject "{\\normalsize " "}•"]} then {
  1149.         message "normalsize text set"
  1150.     } else {
  1151.         message "enter normalsize text"
  1152.     }
  1153. }
  1154. proc large {} {
  1155.     if {[wrapObject "{\\large " "}•"]} then {
  1156.         message "large text set"
  1157.     } else {
  1158.         message "enter large text"
  1159.     }
  1160. }
  1161. proc Large {} {
  1162.     if {[wrapObject "{\\Large " "}•"]} then {
  1163.         message "Large text set"
  1164.     } else {
  1165.         message "enter Large text"
  1166.     }
  1167. }
  1168. proc LARGE {} {
  1169.     if {[wrapObject "{\\LARGE " "}•"]} then {
  1170.         message "LARGE text set"
  1171.     } else {
  1172.         message "enter LARGE text"
  1173.     }
  1174. }
  1175. proc huge {} {
  1176.     if {[wrapObject "{\\huge " "}•"]} then {
  1177.         message "huge text set"
  1178.     } else {
  1179.         message "enter huge text"
  1180.     }
  1181. }
  1182. proc Huge {} {
  1183.     if {[wrapObject "{\\Huge " "}•"]} then {
  1184.         message "Huge text set"
  1185.     } else {
  1186.         message "enter Huge text"
  1187.     }
  1188. }
  1189.  
  1190. #--------------------------------------------------------------------------
  1191. # International:
  1192. #--------------------------------------------------------------------------
  1193.  
  1194. proc {ò} {} {
  1195.     if {[wrapObject "\\`{" "}•"]} then {
  1196.         message "accent set"
  1197.     } else {
  1198.         message "enter single character"
  1199.     }
  1200. }
  1201. proc {ó} {} {
  1202.     if {[wrapObject "\\'{" "}•"]} then {
  1203.         message "accent set"
  1204.     } else {
  1205.         message "enter single character"
  1206.     }
  1207. }
  1208. proc {ô} {} {
  1209.     if {[wrapObject "\\^{" "}•"]} then {
  1210.         message "accent set"
  1211.     } else {
  1212.         message "enter single character"
  1213.     }
  1214. }
  1215. proc {ö} {} {
  1216.     if {[wrapObject "\\\"{" "}•"]} then {
  1217.         message "accent set"
  1218.     } else {
  1219.         message "enter single character"
  1220.     }
  1221. }
  1222. proc {õ} {} {
  1223.     if {[wrapObject "\\~{" "}•"]} then {
  1224.         message "accent set"
  1225.     } else {
  1226.         message "enter single character"
  1227.     }
  1228. }
  1229. proc {ç} {} {
  1230.     if {[wrapObject "\\c{" "}•"]} then {
  1231.         message "accent set"
  1232.     } else {
  1233.         message "enter single character"
  1234.     }
  1235. }
  1236. proc {œ} {} {insertObject "\\oe"}
  1237. proc {Œ} {} {insertObject "\\OE"}
  1238. proc {æ} {} {insertObject "\\ae"}
  1239. proc {Æ} {} {insertObject "\\AE"}
  1240. proc {å} {} {insertObject "\\aa"}
  1241. proc {Å} {} {insertObject "\\AA"}
  1242. proc {ø} {} {insertObject "\\o"}
  1243. proc {Ø} {} {insertObject "\\O"}
  1244. proc {ß} {} {insertObject "\\ss"}
  1245. proc {¿} {} {insertObject "?`"}
  1246. proc {¡} {} {insertObject "!`"}
  1247.  
  1248. #--------------------------------------------------------------------------
  1249. # Environments:
  1250. #--------------------------------------------------------------------------
  1251.  
  1252. proc enumerate {} {
  1253.     global promptNoisily useStatusBar
  1254.     set envName "enumerate"
  1255.     if {$promptNoisily && $useStatusBar} {beep}
  1256.     catch {sPrompt "$envName:  how many items?" 3} numberItems
  1257.     if {$numberItems != "cancel"} then {
  1258.         set body "\t\\item  •"
  1259.         for {set i 1} {$i < $numberItems} {incr i} {
  1260.             append body "\r\r\t\\item  •"
  1261.         }
  1262.         append body "\r"
  1263.         if {[insertEnvironment $envName "" $body]} then {
  1264.             nextTabStop
  1265.             message "type first item"
  1266.         }
  1267.     }
  1268. }
  1269. proc itemize {} {
  1270.     global promptNoisily useStatusBar
  1271.     set envName "itemize"
  1272.     if {$promptNoisily && $useStatusBar} {beep}
  1273.     catch {sPrompt "$envName:  how many items?" 3} numberItems
  1274.     if {$numberItems != "cancel"} then {
  1275.         set body "\t\\item  •"
  1276.         for {set i 1} {$i < $numberItems} {incr i} {
  1277.             append body "\r\r\t\\item  •"
  1278.         }
  1279.         append body "\r"
  1280.         if {[insertEnvironment $envName "" $body]} then {
  1281.             nextTabStop
  1282.             message "type first item"
  1283.         }
  1284.     }
  1285. }
  1286. proc description {} {
  1287.     global promptNoisily useStatusBar
  1288.     set envName "description"
  1289.     if {$promptNoisily && $useStatusBar} {beep}
  1290.     catch {sPrompt "$envName: how many items?" 3} numberItems
  1291.     if {$numberItems != "cancel"} then {
  1292.         set body "\t\\item\[•\]  •"
  1293.         for {set i 1} {$i < $numberItems} {incr i} {
  1294.             append body "\r\r\t\\item\[•\]  •"
  1295.         }
  1296.         append body "\r"
  1297.         if {[insertEnvironment $envName "" $body]} then {
  1298.             nextTabStop
  1299.             message "type first item label"
  1300.         }
  1301.     }
  1302. }
  1303. proc thebibliography {} {
  1304.     global promptNoisily useStatusBar
  1305.     set envName "thebibliography"
  1306.     if {$promptNoisily && $useStatusBar} {beep}
  1307.     catch {sPrompt "$envName:  how many bibitems?" 3} numberItems
  1308.     if {$numberItems != "cancel"} then {
  1309.         set arg "{99}"
  1310.         set body "\t\\bibitem{•}\r\t•"
  1311.         for {set i 1} {$i < $numberItems} {incr i} {
  1312.             append body "\r\r\t\\bibitem{•}\r\t•"
  1313.         }
  1314.         append body "\r"
  1315.         if {[insertEnvironment $envName $arg $body]} then {
  1316.             nextTabStop
  1317.             message "type first bibitem key"
  1318.         }
  1319.     }
  1320. }
  1321. proc slide {} { doWrapEnvironment "slide" }
  1322. proc overlay {} { doWrapEnvironment "overlay" }
  1323. proc note {} { doWrapEnvironment "titlepage" }
  1324. proc figure {} {
  1325.     global useBoxMacro boxMacroName
  1326.     set envName "figure"
  1327.     set arg "\[tbp\]"
  1328.     if {$useBoxMacro} then {
  1329.         set body "\t\\centerline{\\$boxMacroName{•}}\r"
  1330.     }
  1331.     append body "\t\\caption{•}\r"
  1332.     append body "\t\\protect\\label{•}\r"
  1333.     if {$useBoxMacro} then {
  1334.         if {[insertEnvironment $envName $arg $body]} then {
  1335.             set msgText "enter filename"
  1336.         } else {
  1337.             return
  1338.         }
  1339.     } else {
  1340.         if {[wrapEnvironment $envName $arg $body]} then {
  1341.             set msgText "enter caption"
  1342.         } else {
  1343.             set msgText "enter body of $envName environment"
  1344.         }
  1345.     }
  1346.     nextTabStop
  1347.     message $msgText
  1348. }
  1349. proc table {} {
  1350.     set envName "table"
  1351.     set arg "\[tbp\]"
  1352.     append body "\t\\caption{•}\r"
  1353.     append body "\t\\protect\\label{•}\r"
  1354.     if {[wrapEnvironment $envName $arg $body]} then {
  1355.         set msgText "enter caption"
  1356.     } else {
  1357.         set msgText "enter body of $envName environment"
  1358.     }
  1359.     nextTabStop
  1360.     message $msgText
  1361. }
  1362. proc buildRow {jmax} {
  1363.     set txt "•"
  1364.     for {set j 1} {$j < $jmax} {incr j} {
  1365.         append txt " & •"
  1366.     }
  1367.     return $txt
  1368. }
  1369. proc tabular {} {
  1370.     global promptNoisily useStatusBar
  1371.     set envName "tabular"
  1372.     if {$promptNoisily && $useStatusBar} {beep}
  1373.     catch {sPrompt "$envName:  how many rows?" 3} numberRows
  1374.     if {$numberRows != "cancel"} then {
  1375.         if {$promptNoisily && $useStatusBar} {beep}
  1376.         catch {sPrompt "$envName:  how many columns?" 3} numberCols
  1377.         if {$numberCols != "cancel"} then {
  1378.             set arg "{|"
  1379.             for {set j 1} {$j <= $numberCols} {incr j} {
  1380.                 append arg "c|"
  1381.             }
  1382.             append arg "}"
  1383.             set body "\t\\hline\r"
  1384.             for {set i 1} {$i <= $numberRows} {incr i} {
  1385.                 append body "\t[buildRow $numberCols]"
  1386.                 append body "  \\\\\r\t\\hline\r"
  1387.             }
  1388.             if {[insertEnvironment $envName $arg $body]} then {
  1389.                 nextTabStop
  1390.                 message "type first item"
  1391.             }
  1392.         }
  1393.     }
  1394. }
  1395. proc verbatim {} { doWrapEnvironment "verbatim" }
  1396. proc quote {} { doWrapEnvironment "quote" }
  1397. proc quotation {} { doWrapEnvironment "quotation" }
  1398. proc verse {} { doWrapEnvironment "verse" }
  1399. proc flushleft {} { doWrapEnvironment "flushleft" }
  1400. proc center {} { doWrapEnvironment "center" }
  1401. proc flushright {} { doWrapEnvironment "flushright" }
  1402. proc general {} {
  1403.     catch {prompt "What environment?" "center"} environmentName
  1404.     if {$environmentName != "cancel"} {
  1405.         doWrapEnvironment "$environmentName"
  1406.     }
  1407. }
  1408.  
  1409. #--------------------------------------------------------------------------
  1410. # Boxes:
  1411. #--------------------------------------------------------------------------
  1412.  
  1413. proc mbox {} {
  1414.     if {[wrapObject "\\mbox{" "}•"]} then {
  1415.         message "mbox set"
  1416.     } else {
  1417.         message "enter text"
  1418.     }
  1419. }
  1420. proc makebox {} {
  1421.     if {[wrapObject "\\makebox\[•\]\[•\]{" "}•"]} then {
  1422.         message "makebox set; enter the width and position"
  1423.     } else {
  1424.         message "enter the width and position of the makebox, then the text"
  1425.     }
  1426. }
  1427. proc fbox {} {
  1428.     if {[wrapObject "\\fbox{" "}•"]} then {
  1429.         message "fbox set"
  1430.     } else {
  1431.         message "enter text"
  1432.     }
  1433. }
  1434. proc framebox {} {
  1435.     if {[wrapObject "\\framebox\[•\]\[•\]{" "}•"]} then {
  1436.         message "framebox set; enter the width and position"
  1437.     } else {
  1438.         message "enter the width and position of the framebox, then the text"
  1439.     }
  1440. }
  1441. proc newsavebox {} {
  1442.     if {[wrapObject "\\newsavebox{" "}•"]} then {
  1443.         message "newsavebox defined"
  1444.     } else {
  1445.         message "enter the command name of the sbox or savebox"
  1446.     }
  1447. }
  1448. proc sbox {} {
  1449.     if {[wrapObject "\\sbox{•}{" "}•"]} then {
  1450.         message "sbox set; enter the command name"
  1451.     } else {
  1452.         message "enter the command name of the sbox, then the text"
  1453.     }
  1454. }
  1455. proc savebox {} {
  1456.     if {[wrapObject "\\savebox{•}\[•\]\[•\]{" "}•"]} then {
  1457.         message "savebox set; enter the command name"
  1458.     } else {
  1459.         message "enter the command name of the savebox"
  1460.     }
  1461. }
  1462. proc usebox {} {
  1463.     if {[wrapObject "\\usebox{" "}•"]} then {
  1464.         message "usebox declared"
  1465.     } else {
  1466.         message "enter the command name of the sbox or savebox"
  1467.     }
  1468. }
  1469. proc raisebox {} {
  1470.     if {[wrapObject "\\raisebox{•}\[•\]\[•\]{" "}•"]} then {
  1471.         message "raisebox set; enter the displacement"
  1472.     } else {
  1473.         message "enter the displacement of the raisebox"
  1474.     }
  1475. }
  1476. proc parbox {} {
  1477.     if {[wrapObject "\\parbox\[•\]\{•\}{" "}•"]} then {
  1478.         message "parbox set; enter the position and width"
  1479.     } else {
  1480.         message "enter the position and width of the parbox, then the text"
  1481.     }
  1482. }
  1483. proc minipage {} {
  1484.     set arg "\[•\]{•}"
  1485.     wrapEnvironment "minipage" $arg ""
  1486.     nextTabStop
  1487.     message "enter the position of the minipage, then the width"
  1488. }
  1489. proc rule {} {
  1490.     insertObject "\\rule\[•\]\{•\}{•}•"
  1491.     nthTabStop -4
  1492.     message "enter the displacement of the rule, then width and height"
  1493. }
  1494.  
  1495. #--------------------------------------------------------------------------
  1496. # Misc:
  1497. #--------------------------------------------------------------------------
  1498.  
  1499. proc ldots {} {insertObject "\\ldots"}
  1500. proc {en-dash} {} {insertObject "--"}
  1501. proc {em-dash} {} {insertObject "---"}
  1502. proc texLogo {} {insertObject "\\TeX"}
  1503. proc latexLogo {} {insertObject "\\LaTeX"}
  1504. proc latex2eLogo {} {insertObject "\\LaTeXe"}
  1505. proc today {} {insertObject "\\today"}
  1506. proc dag {} {insertObject "\\dag"}
  1507. proc ddag {} {insertObject "\\ddag"}
  1508. proc sectionMark {} {insertObject "\\S"}
  1509. proc paragraphMark {} {insertObject "\\P"}
  1510. proc copyright {} {insertObject "\\copyright"}
  1511. proc pounds {} {insertObject "\\pounds"}
  1512. proc quotes {} {
  1513.     if {[wrapObject "`" "'•"]} then {
  1514.         message "text quoted"
  1515.     } else {
  1516.         message "enter text"
  1517.     }
  1518. }
  1519. proc dblQuotes {} {
  1520.     if {[wrapObject "``" "''•"]} then {
  1521.         message "text double quoted"
  1522.     } else {
  1523.         message "enter text"
  1524.     }
  1525. }
  1526. proc marginalNote {} {
  1527.     if {[wrapObject "\\marginpar{" "}•"]} then {
  1528.         message "marginal note set"
  1529.     } else {
  1530.         message "enter marginal note"
  1531.     }
  1532. }
  1533. proc footnote {} {
  1534.     if {[wrapObject "\\footnote{" "}•"]} then {
  1535.         message "footnote set"
  1536.     } else {
  1537.         message "enter footnote"
  1538.     }
  1539. }
  1540. proc label {} {
  1541.     if {[wrapObject "\\label{" "}•"]} then {
  1542.         message "label defined"
  1543.     } else {
  1544.         message "enter label"
  1545.     }
  1546. }
  1547. proc ref {} { 
  1548.     if {[wrapObject "\\ref{" "}•"]} then {
  1549.         message "cross-reference made"
  1550.     } else {
  1551.         message "enter cross-reference"
  1552.     }
  1553. }
  1554. proc pageref {} { 
  1555.     if {[wrapObject "\\pageref{" "}•"]} then {
  1556.         message "page reference made"
  1557.     } else {
  1558.         message "enter page reference"
  1559.     }
  1560. }
  1561. proc cite {} {
  1562.     if {[wrapObject "\\cite{" "}•"]} then {
  1563.         message "citation made"
  1564.     } else {
  1565.         message "enter citation"
  1566.     }
  1567. }
  1568. proc item {} {insertObject "\\item"}
  1569. proc bibitem {} {
  1570.     if {[wrapObject "\\bibitem{" "}•"]} then {
  1571.         message "bibitem set"
  1572.     } else {
  1573.         message "enter bibitem"
  1574.     }
  1575. }
  1576.  
  1577.  
  1578. #############################################################################
  1579. # 
  1580. # Math Mode Macros
  1581. #
  1582. #############################################################################
  1583.  
  1584. #--------------------------------------------------------------------------
  1585. # Math Modes:
  1586. #--------------------------------------------------------------------------
  1587.  
  1588. proc texMath {} {
  1589.     if {[wrapObject "$" "$•"]} then {
  1590.         message "formula set"
  1591.     } else {
  1592.         message "enter formula"
  1593.     }
  1594. }
  1595. proc texDisplaymath {} {
  1596.     if {[wrapObject "$$" "$$•"]} then {
  1597.         message "displayed formula set"
  1598.     } else {
  1599.         message "enter displayed formula"
  1600.     }
  1601. }
  1602. proc latexMath {} {
  1603.     if {[wrapObject "\\( " " \\)•"]} then {
  1604.         message "formula set"
  1605.     } else {
  1606.         message "enter formula"
  1607.     }
  1608. }
  1609. proc latexDisplaymath {} {
  1610.     if {[wrapObject "\\\[ " " \\\]•"]} then {
  1611.         message "displayed formula set"
  1612.     } else {
  1613.         message "enter displayed formula"
  1614.     }
  1615. }
  1616.  
  1617. #--------------------------------------------------------------------------
  1618. # Math Style:
  1619. #--------------------------------------------------------------------------
  1620.  
  1621. proc mathit {} {
  1622.     if {[wrapObject "\\mathit{" "}•"]} then {
  1623.         message "selected text is math italic"
  1624.     } else {
  1625.         message "enter text to be math italic"
  1626.     }
  1627. }
  1628. proc mathrm {} {
  1629.     if {[wrapObject "\\mathrm{" "}•"]} then {
  1630.         message "selected text is math roman"
  1631.     } else {
  1632.         message "enter text to be math roman"
  1633.     }
  1634. }
  1635. proc mathbf {} {
  1636.     if {[wrapObject "\\mathbf{" "}•"]} then {
  1637.         message "selected text is math bold"
  1638.     } else {
  1639.         message "enter text to be math bold"
  1640.     }
  1641. }
  1642. proc mathsf {} {
  1643.     if {[wrapObject "\\mathsf{" "}•"]} then {
  1644.         message "selected text is math sans serif"
  1645.     } else {
  1646.         message "enter text to be math sans serif"
  1647.     }
  1648. }
  1649. proc mathtt {} {
  1650.     if {[wrapObject "\\mathtt{" "}•"]} then {
  1651.         message "selected text is math typewriter"
  1652.     } else {
  1653.         message "enter text to be math typewriter"
  1654.     }
  1655. }
  1656. proc mathcal {} {
  1657.     # Allow upper-case arguments only:
  1658.     if {[isSelection] && ![isUppercase]} then {
  1659.         alertnote "argument to \\mathcal must be uppercase"
  1660.         return
  1661.     }
  1662.     if {[wrapObject "\\mathcal{" "}•"]} then {
  1663.         message "selected text is calligraphic"
  1664.     } else {
  1665.         message "enter text to be calligraphic (UPPERCASE letters only)"
  1666.     }
  1667. }
  1668. proc displaystyle {} {
  1669.     if {[wrapObject "{\\displaystyle " "}•"]} then {
  1670.         message "displaystyle set"
  1671.     } else {
  1672.         message "enter displaystyle text"
  1673.     }
  1674. }
  1675. proc textstyle {} {
  1676.     if {[wrapObject "{\\textstyle " "}•"]} then {
  1677.         message "textstyle set"
  1678.     } else {
  1679.         message "enter textstyle text"
  1680.     }
  1681. }
  1682. proc scriptstyle {} {
  1683.     if {[wrapObject "{\\scriptstyle " "}•"]} then {
  1684.         message "scriptstyle set"
  1685.     } else {
  1686.         message "enter scriptstyle text"
  1687.     }
  1688. }
  1689. proc scriptscriptstyle {} {
  1690.     if {[wrapObject "{\\scriptscriptstyle " "}•"]} then {
  1691.         message "scriptscriptstyle set"
  1692.     } else {
  1693.         message "enter scriptscriptstyle text"
  1694.     }
  1695. }
  1696.  
  1697. #--------------------------------------------------------------------------
  1698. # Math Environments:
  1699. #--------------------------------------------------------------------------
  1700.  
  1701. proc math {} { doWrapEnvironment "math" }
  1702. proc displaymath {} { doWrapEnvironment "displaymath" }
  1703. proc equation {} {
  1704.     set envName "equation"
  1705.     set body "\t\\label{•}\r"
  1706.     if {[wrapEnvironment $envName "" $body]} then {
  1707.         set msgText "equation wrapped"
  1708.     } else {
  1709.         set msgText "enter equation"
  1710.     }
  1711.     nextTabStop
  1712.     message $msgText
  1713. }
  1714. proc myArray {} {
  1715.     global promptNoisily useStatusBar
  1716.     set envName "array"
  1717.     if {$promptNoisily && $useStatusBar} {beep}
  1718.     catch {sPrompt "$envName:  how many rows?" 3} numberRows
  1719.     if {$numberRows != "cancel"} then {
  1720.         if {$promptNoisily && $useStatusBar} {beep}
  1721.         catch {sPrompt "$envName:  how many columns?" 3} numberCols
  1722.         if {$numberCols != "cancel"} then {
  1723.             set arg "{"
  1724.             for {set j 1} {$j <= $numberCols} {incr j} {
  1725.                 append arg "c"
  1726.             }
  1727.             append arg "}"
  1728.             set row "\t[buildRow $numberCols]"
  1729.             for {set i 1} {$i < $numberRows} {incr i} {
  1730.                 append body $row
  1731.                 append body "  \\\\\r\t\r"
  1732.             }
  1733.             append body $row
  1734.             append body "\r"
  1735.             if {[insertEnvironment $envName $arg $body]} then {
  1736.                 nextTabStop
  1737.                 message "type first item"
  1738.             }
  1739.         }
  1740.     }
  1741. }
  1742. proc eqnarrayStar {} {
  1743.     global promptNoisily useStatusBar
  1744.     set envName "eqnarray*"
  1745.     if {$promptNoisily && $useStatusBar} {beep}
  1746.     catch {sPrompt "$envName:  how many rows?" 3} numberRows
  1747.     if {$numberRows != "cancel"} then {
  1748.         set row "\t[buildRow 3]"
  1749.         for {set i 1} {$i < $numberRows} {incr i} {
  1750.             append body $row
  1751.             append body "  \\\\\r"
  1752.         }
  1753.         append body $row
  1754.         append body "\r"
  1755.         if {[insertEnvironment $envName "" $body]} then {
  1756.             nextTabStop
  1757.             message "type first item"
  1758.         }
  1759.     }
  1760. }
  1761. proc eqnarray {} {
  1762.     global promptNoisily useStatusBar
  1763.     set envName "eqnarray"
  1764.     if {$promptNoisily && $useStatusBar} {beep}
  1765.     catch {sPrompt "$envName:  how many rows?" 3} numberRows
  1766.     if {$numberRows != "cancel"} then {
  1767.         set row "\t[buildRow 3]\r\t\\label{•}"
  1768.         for {set i 1} {$i < $numberRows} {incr i} {
  1769.             append body $row
  1770.             append body "  \\\\\r"
  1771.         }
  1772.         append body $row
  1773.         append body "\r"
  1774.         if {[insertEnvironment $envName "" $body]} then {
  1775.             nextTabStop
  1776.             message "type first item"
  1777.         }
  1778.     }
  1779. }
  1780.  
  1781. #--------------------------------------------------------------------------
  1782. # Formulas:
  1783. #--------------------------------------------------------------------------
  1784.  
  1785. proc subscript {} {
  1786.     if {[wrapObject "_{" "}•"]} then {
  1787.         message "subscript set"
  1788.     } else {
  1789.         message "enter subscript"
  1790.     }
  1791. }
  1792. proc superscript {} {
  1793.     if {[wrapObject "^{" "}•"]} then {
  1794.         message "superscript set"
  1795.     } else {
  1796.         message "enter superscript"
  1797.     }
  1798. }
  1799. proc fraction {} {
  1800.     set currentPos [getPos]
  1801.     if {[isSelection]} then {
  1802.         set selection [getSelect]
  1803.         set args [split $selection /]
  1804.         set len [llength $args]
  1805.         deleteText $currentPos [selEnd]
  1806.         if {$len == 1} then {
  1807.             insertText "\\frac{" $selection "}{•}•"
  1808.             goto $currentPos
  1809.             nextTabStop
  1810.             message "enter denominator"
  1811.         } else {
  1812.             set firstArg [lindex $args 0]
  1813.             set restArgs [lrange $args 1 [expr $len-1]]
  1814.             insertText "\\frac{" $firstArg "}{" [join $restArgs /] "}"
  1815.             if {$len > 2} {message "beware of multiple /"}
  1816.         }
  1817.     } else {
  1818.         insertText "\\frac{•}{•}•"
  1819.         goto $currentPos
  1820.         nextTabStop
  1821.         message "enter numerator"
  1822.     }
  1823. }
  1824. proc squareRoot {} {
  1825.     if {[wrapObject "\\sqrt{" "}•"]} then {
  1826.         message "square root set"
  1827.     } else {
  1828.         message "enter formula"
  1829.     }
  1830. }
  1831. proc nthRoot {} {
  1832.     if {[wrapObject "\\sqrt\[•\]{" "}•"]} then {
  1833.         message "enter root"
  1834.     } else {
  1835.         message "enter root, then formula"
  1836.     }
  1837. }
  1838. proc oneParameter {} {
  1839.     catch {prompt "Command name?" "sqrt"} commandName
  1840.     if {$commandName != "cancel"} {wrapObject "\\$commandName{" "}•"}
  1841. }
  1842. proc twoParameters {} {
  1843.     catch {prompt "Command name?" "frac"} commandName
  1844.     if {$commandName != "cancel"} then {
  1845.         set currentPos [getPos]
  1846.         if {[insertObject "\\$commandName{•}{•}•"]} then {
  1847.             goto $currentPos
  1848.             nextTabStop
  1849.         }
  1850.     }
  1851. }
  1852.  
  1853. #--------------------------------------------------------------------------
  1854. # Greek:
  1855. #--------------------------------------------------------------------------
  1856.  
  1857. proc alpha {} {insertObject "\\alpha"}
  1858. proc beta {} {insertObject "\\beta"}
  1859. proc gamma {} {insertObject "\\gamma"}
  1860. proc delta {} {insertObject "\\delta"}
  1861. proc epsilon {} {insertObject "\\epsilon"}
  1862. proc zeta {} {insertObject "\\zeta"}
  1863. proc eta {} {insertObject "\\eta"}
  1864. proc theta {} {insertObject "\\theta"}
  1865. proc iota {} {insertObject "\\iota"}
  1866. proc kappa {} {insertObject "\\kappa"}
  1867. proc lambda {} {insertObject "\\lambda"}
  1868. proc mu {} {insertObject "\\mu"}
  1869. proc nu {} {insertObject "\\nu"}
  1870. proc xi {} {insertObject "\\xi"}
  1871. proc omicron {} {insertObject "o"}
  1872. proc pi {} {insertObject "\\pi"}
  1873. proc rho {} {insertObject "\\rho"}
  1874. proc sigma {} {insertObject "\\sigma"}
  1875. proc tau {} {insertObject "\\tau"}
  1876. proc upsilon {} {insertObject "\\upsilon"}
  1877. proc phi {} {insertObject "\\phi"}
  1878. proc chi {} {insertObject "\\chi"}
  1879. proc psi {} {insertObject "\\psi"}
  1880. proc omega {} {insertObject "\\omega"}
  1881.  
  1882. proc Gamma {} {insertObject "\\Gamma"}
  1883. proc Delta {} {insertObject "\\Delta"}
  1884. proc Theta {} {insertObject "\\Theta"}
  1885. proc Lambda {} {insertObject "\\Lambda"}
  1886. proc Xi {} {insertObject "\\Xi"}
  1887. proc Pi {} {insertObject "\\Pi"}
  1888. proc Sigma {} {insertObject "\\Sigma"}
  1889. proc Upsilon {} {insertObject "\\Upsilon"}
  1890. proc Phi {} {insertObject "\\Phi"}
  1891. proc Psi {} {insertObject "\\Psi"}
  1892. proc Omega {} {insertObject "\\Omega"}
  1893.  
  1894. proc varepsilon {} {insertObject "\\varepsilon"}
  1895. proc vartheta {} {insertObject "\\vartheta"}
  1896. proc varpi {} {insertObject "\\varpi"}
  1897. proc varrho {} {insertObject "\\varrho"}
  1898. proc varsigma {} {insertObject "\\varsigma"}
  1899. proc varphi {} {insertObject "\\varphi"}
  1900.  
  1901. #--------------------------------------------------------------------------
  1902. # Binary Ops:
  1903. #--------------------------------------------------------------------------
  1904.  
  1905. proc pm {} {insertObject "\\pm"}
  1906. proc mp {} {insertObject "\\mp"}
  1907. proc times {} {insertObject "\\times"}
  1908. proc div {} {insertObject "\\div"}
  1909. proc ast {} {insertObject "\\ast"}
  1910. proc star {} {insertObject "\\star"}
  1911. proc circ {} {insertObject "\\circ"}
  1912. proc bullet {} {insertObject "\\bullet"}
  1913. proc cdot {} {insertObject "\\cdot"}
  1914. proc cap {} {insertObject "\\cap"}
  1915. proc cup {} {insertObject "\\cup"}
  1916. proc uplus {} {insertObject "\\uplus"}
  1917. proc sqcap {} {insertObject "\\sqcap"}
  1918. proc sqcup {} {insertObject "\\sqcup"}
  1919. proc vee {} {insertObject "\\vee"}
  1920. proc wedge {} {insertObject "\\wedge"}
  1921. proc setminus {} {insertObject "\\setminus"}
  1922. proc wr {} {insertObject "\\wr"}
  1923. proc diamond {} {insertObject "\\diamond"}
  1924. proc bigtriangleup {} {insertObject "\\bigtriangleup"}
  1925. proc bigtriangledown {} {insertObject "\\bigtriangledown"}
  1926. proc triangleleft {} {insertObject "\\triangleleft"}
  1927. proc triangleright {} {insertObject "\\triangleright"}
  1928. proc lhd {} { if {[isSymbolPackageLoaded]} then {insertObject "\\lhd"} }
  1929. proc rhd {} { if {[isSymbolPackageLoaded]} then {insertObject "\\rhd"} }
  1930. proc unlhd {} { if {[isSymbolPackageLoaded]} then {insertObject "\\unlhd"} }
  1931. proc unrhd {} { if {[isSymbolPackageLoaded]} then {insertObject "\\unrhd"} }
  1932. proc oplus {} {insertObject "\\oplus"}
  1933. proc ominus {} {insertObject "\\ominus"}
  1934. proc otimes {} {insertObject "\\otimes"}
  1935. proc oslash {} {insertObject "\\oslash"}
  1936. proc odot {} {insertObject "\\odot"}
  1937. proc bigcirc {} {insertObject "\\bigcirc"}
  1938. proc dagger {} {insertObject "\\dagger"}
  1939. proc ddagger {} {insertObject "\\ddagger"}
  1940. proc amalg {} {insertObject "\\amalg"}
  1941.  
  1942. #--------------------------------------------------------------------------
  1943. # Relations:
  1944. #--------------------------------------------------------------------------
  1945.  
  1946. proc leq {} {insertObject "\\leq"}
  1947. proc prec {} {insertObject "\\prec"}
  1948. proc preceq {} {insertObject "\\preceq"}
  1949. proc myLl {} {insertObject "\\ll"}
  1950. proc subset {} {insertObject "\\subset"}
  1951. proc subseteq {} {insertObject "\\subseteq"}
  1952. proc sqsubset {} {
  1953.     if {[isSymbolPackageLoaded]} then {insertObject "\\sqsubset"}
  1954. }
  1955. proc sqsubseteq {} {insertObject "\\sqsubseteq"}
  1956. proc in {} {insertObject "\\in"}
  1957. proc vdash {} {insertObject "\\vdash"}
  1958.  
  1959. proc geq {} {insertObject "\\geq"}
  1960. proc succ {} {insertObject "\\succ"}
  1961. proc succeq {} {insertObject "\\succeq"}
  1962. proc gg {} {insertObject "\\gg"}
  1963. proc supset {} {insertObject "\\supset"}
  1964. proc supseteq {} {insertObject "\\supseteq"}
  1965. proc sqsupset {} {
  1966.     if {[isSymbolPackageLoaded]} then {insertObject "\\sqsupset"}
  1967. }
  1968. proc sqsupseteq {} {insertObject "\\sqsupseteq"}
  1969. proc ni {} {insertObject "\\ni"}
  1970. proc dashv {} {insertObject "\\dashv"}
  1971.  
  1972. proc equiv {} {insertObject "\\equiv"}
  1973. proc sim {} {insertObject "\\sim"}
  1974. proc simeq {} {insertObject "\\simeq"}
  1975. proc asymp {} {insertObject "\\asymp"}
  1976. proc approx {} {insertObject "\\approx"}
  1977. proc cong {} {insertObject "\\cong"}
  1978. proc neq {} {insertObject "\\neq"}
  1979. proc doteq {} {insertObject "\\doteq"}
  1980. proc propto {} {insertObject "\\propto"}
  1981.  
  1982. proc models {} {insertObject "\\models"}
  1983. proc perp {} {insertObject "\\perp"}
  1984. proc mid {} {insertObject "\\mid"}
  1985. proc parallel {} {insertObject "\\parallel"}
  1986. proc bowtie {} {insertObject "\\bowtie"}
  1987. proc myJoin {} { if {[isSymbolPackageLoaded]} then {insertObject "\\join"} }
  1988. proc smile {} {insertObject "\\smile"}
  1989. proc frown {} {insertObject "\\frown"}
  1990.  
  1991. #--------------------------------------------------------------------------
  1992. # Arrows:
  1993. #--------------------------------------------------------------------------
  1994.  
  1995. proc leftarrow {} {insertObject "\\leftarrow"}
  1996. proc Leftarrow {} {insertObject "\\Leftarrow"}
  1997. proc rightarrow {} {insertObject "\\rightarrow"}
  1998. proc Rightarrow {} {insertObject "\\Rightarrow"}
  1999. proc leftrightarrow {} {insertObject "\\leftrightarrow"}
  2000. proc Leftrightarrow {} {insertObject "\\Leftrightarrow"}
  2001. proc mapsto {} {insertObject "\\mapsto"}
  2002. proc hookleftarrow {} {insertObject "\\hookleftarrow"}
  2003. proc leftharpoonup {} {insertObject "\\leftharpoonup"}
  2004. proc leftharpoondown {} {insertObject "\\leftharpoondown"}
  2005. proc rightleftharpoons {} {insertObject "\\rightleftharpoons"}
  2006.  
  2007. proc longleftarrow {} {insertObject "\\longleftarrow"}
  2008. proc Longleftarrow {} {insertObject "\\Longleftarrow"}
  2009. proc longrightarrow {} {insertObject "\\longrightarrow"}
  2010. proc Longrightarrow {} {insertObject "\\Longrightarrow"}
  2011. proc longleftrightarrow {} {insertObject "\\longleftrightarrow"}
  2012. proc Longleftrightarrow {} {insertObject "\\Longleftrightarrow"}
  2013. proc longmapsto {} {insertObject "\\longmapsto"}
  2014. proc hookrightarrow {} {insertObject "\\hookrightarrow"}
  2015. proc rightharpoonup {} {insertObject "\\rightharpoonup"}
  2016. proc rightharpoondown {} {insertObject "\\rightharpoondown"}
  2017. proc leadsto {} {
  2018.     if {[isSymbolPackageLoaded]} then {insertObject "\\leadsto"}
  2019. }
  2020. proc uparrow {} {insertObject "\\uparrow"}
  2021. proc Uparrow {} {insertObject "\\Uparrow"}
  2022. proc downarrow {} {insertObject "\\downarrow"}
  2023. proc Downarrow {} {insertObject "\\Downarrow"}
  2024. proc updownarrow {} {insertObject "\\updownarrow"}
  2025. proc Updownarrow {} {insertObject "\\Updownarrow"}
  2026. proc nearrow {} {insertObject "\\nearrow"}
  2027. proc searrow {} {insertObject "\\searrow"}
  2028. proc swarrow {} {insertObject "\\swarrow"}
  2029. proc nwarrow {} {insertObject "\\nwarrow"}
  2030.  
  2031. #--------------------------------------------------------------------------
  2032. # Dots:
  2033. #--------------------------------------------------------------------------
  2034.  
  2035. proc cdots {} {insertObject "\\cdots"}
  2036. proc vdots {} {insertObject "\\vdots"}
  2037. proc ddots {} {insertObject "\\ddots"}
  2038.  
  2039. #--------------------------------------------------------------------------
  2040. # Symbols:
  2041. #--------------------------------------------------------------------------
  2042.  
  2043. proc aleph {} {insertObject "\\aleph"}
  2044. proc hbar {} {insertObject "\\hbar"}
  2045. proc imath {} {insertObject "\\imath"}
  2046. proc jmath {} {insertObject "\\jmath"}
  2047. proc ell {} {insertObject "\\ell"}
  2048. proc wp {} {insertObject "\\wp"}
  2049. proc Re {} {insertObject "\\Re"}
  2050. proc Im {} {insertObject "\\Im"}
  2051. proc mho {} { if {[isSymbolPackageLoaded]} then {insertObject "\\mho"} }
  2052. proc prime {} {insertObject "\\prime"}
  2053. proc emptyset {} {insertObject "\\emptyset"}
  2054. proc nabla {} {insertObject "\\nabla"}
  2055. proc surd {} {insertObject "\\surd"}
  2056. proc top {} {insertObject "\\top"}
  2057. proc bot {} {insertObject "\\bot"}
  2058. # proc | {} {insertObject "\\|"}
  2059. proc angle {} {insertObject "\\angle"}
  2060. proc forall {} {insertObject "\\forall"}
  2061. proc exists {} {insertObject "\\exists"}
  2062. proc neg {} {insertObject "\\neg"}
  2063. proc flat {} {insertObject "\\flat"}
  2064. proc natural {} {insertObject "\\natural"}
  2065. proc sharp {} {insertObject "\\sharp"}
  2066. proc backslash {} {insertObject "\\backslash"}
  2067. proc partial {} {insertObject "\\partial"}
  2068. proc infty {} {insertObject "\\infty"}
  2069. proc Box {} { if {[isSymbolPackageLoaded]} then {insertObject "\\Box"} }
  2070. proc Diamond {} {
  2071.     if {[isSymbolPackageLoaded]} then {insertObject "\\Diamond"}
  2072. }
  2073. proc triangle {} {insertObject "\\triangle"}
  2074. proc clubsuit {} {insertObject "\\clubsuit"}
  2075. proc diamondsuit {} {insertObject "\\diamondsuit"}
  2076. proc heartsuit {} {insertObject "\\heartsuit"}
  2077. proc spadesuit {} {insertObject "\\spadesuit"}
  2078.  
  2079. #--------------------------------------------------------------------------
  2080. # Functions:
  2081. #--------------------------------------------------------------------------
  2082.  
  2083. proc arccos {} {insertObject "\\arccos"}
  2084. proc arcsin {} {insertObject "\\arcsin"}
  2085. proc arctan {} {insertObject "\\arctan"}
  2086. proc arg {} {insertObject "\\arg"}
  2087. proc cos {} {insertObject "\\cos"}
  2088. proc cosh {} {insertObject "\\cosh"}
  2089. proc cot {} {insertObject "\\cot"}
  2090. proc coth {} {insertObject "\\coth"}
  2091. proc csc {} {insertObject "\\csc"}
  2092. proc deg {} {insertObject "\\deg"}
  2093. proc det {} {insertObject "\\det"}
  2094. proc dim {} {insertObject "\\dim"}
  2095. proc exp {} {insertObject "\\exp"}
  2096. proc gcd {} {insertObject "\\gcd"}
  2097. proc hom {} {insertObject "\\hom"}
  2098. proc inf {} {insertObject "\\inf"}
  2099. proc ker {} {insertObject "\\ker"}
  2100. proc lg {} {insertObject "\\lg"}
  2101. proc lim {} {insertObject "\\lim"}
  2102. proc liminf {} {insertObject "\\liminf"}
  2103. proc limsup {} {insertObject "\\limsup"}
  2104. proc ln {} {insertObject "\\ln"}
  2105. proc log {} {insertObject "\\log"}
  2106. proc max {} {insertObject "\\max"}
  2107. proc min {} {insertObject "\\min"}
  2108. proc Pr {} {insertObject "\\Pr"}
  2109. proc sec {} {insertObject "\\sec"}
  2110. proc sin {} {insertObject "\\sin"}
  2111. proc sinh {} {insertObject "\\sinh"}
  2112. proc sup {} {insertObject "\\sup"}
  2113. proc tan {} {insertObject "\\tan"}
  2114. proc tanh {} {insertObject "\\tanh"}
  2115.  
  2116. proc bmod {} {insertObject "\\bmod"}
  2117. proc pmod {} {
  2118.     if {[wrapObject "\\pmod{" "}•"]} then {
  2119.         message "parenthesized mod set"
  2120.     } else {
  2121.         message "enter formula"
  2122.     }
  2123. }
  2124.  
  2125. #--------------------------------------------------------------------------
  2126. # Large Ops:
  2127. #--------------------------------------------------------------------------
  2128.  
  2129. proc insertLargeOp {commandName} {
  2130.     set currentPos [getPos]
  2131.     insertText "\\$commandName"
  2132.     insertText "_{•}^{•}•"
  2133.     goto $currentPos
  2134.     nextTabStop
  2135. }
  2136. proc sum {} {insertLargeOp "sum"}
  2137. proc prod {} {insertLargeOp "prod"}
  2138. proc coprod {} {insertLargeOp "coprod"}
  2139. proc int {} {insertLargeOp "int"}
  2140. proc oint {} {insertLargeOp "oint"}
  2141. proc bigcap {} {insertLargeOp "bigcap"}
  2142. proc bigcup {} {insertLargeOp "bigcup"}
  2143. proc bigsqcap {} {insertLargeOp "bigsqcap"}
  2144. proc bigsqcup {} {insertLargeOp "bigsqcup"}
  2145. proc bigvee {} {insertLargeOp "bigvee"}
  2146. proc bigwedge {} {insertLargeOp "bigwedge"}
  2147. proc bigodot {} {insertLargeOp "bigodot"}
  2148. proc bigotimes {} {insertLargeOp "bigotimes"}
  2149. proc bigoplus {} {insertLargeOp "bigoplus"}
  2150. proc biguplus {} {insertLargeOp "biguplus"}
  2151.  
  2152. #--------------------------------------------------------------------------
  2153. # Delimiters:
  2154. #--------------------------------------------------------------------------
  2155.  
  2156. proc delimitObject {leftDelim rightDelim} {
  2157.     if {[wrapObject $leftDelim $rightDelim]} then {
  2158.         message "formula delimited"
  2159.     } else {
  2160.         message "enter formula"
  2161.     }
  2162. }
  2163. proc parentheses {} { delimitObject "(" ")•" }
  2164. proc brackets {} { delimitObject "\[" "\]•" }
  2165. proc braces {} { delimitObject "\\\{" "\\\}•" }
  2166. proc absoluteValue {} { delimitObject "|" "|•" }
  2167. proc getDelims {} {
  2168.     catch {prompt "Choose delimiters:" "parentheses" "" "parentheses" \
  2169.                   "brackets" "braces" "angle brackets" "vertical bars" \
  2170.                   "double bars" "ceiling" "floor"} delimType
  2171.     if {$delimType != "cancel"} then {
  2172.         case $delimType in {
  2173.             "parentheses" {
  2174.                 set leftDelim "("
  2175.                 set rightDelim ")"
  2176.             }
  2177.             "brackets" {
  2178.                 set leftDelim "\["
  2179.                 set rightDelim "\]"
  2180.             }
  2181.             "braces" {
  2182.                 set leftDelim "\\\{"
  2183.                 set rightDelim "\\\}"
  2184.             }
  2185.             "{vertical bars}" {
  2186.                 set leftDelim "|"
  2187.                 set rightDelim "|"
  2188.             }
  2189.             "{double bars}" {
  2190.                 set leftDelim "\\|"
  2191.                 set rightDelim "\\|"
  2192.             }
  2193.             "{angle brackets}" {
  2194.                 set leftDelim "\\langle"
  2195.                 set rightDelim "\\rangle"
  2196.             }
  2197.             "ceiling" {
  2198.                 set leftDelim "\\lceil"
  2199.                 set rightDelim "\\rceil"
  2200.             }
  2201.             "floor" {
  2202.                 set leftDelim "\\lfloor"
  2203.                 set rightDelim "\\rfloor"
  2204.             }
  2205.             default {
  2206.                 alertnote "\"$delimType\" not recognized"
  2207.                 return ""
  2208.             }
  2209.         }
  2210.         return [list $leftDelim $rightDelim]
  2211.     } else {return ""}
  2212. }
  2213. proc otherDelims {} {
  2214.     set delims [getDelims]
  2215.     if {$delims != ""} then {
  2216.         set leftDelim [lindex $delims 0]
  2217.         set rightDelim [lindex $delims 1]
  2218.         delimitObject "$leftDelim" "$rightDelim•"
  2219.     }
  2220. }
  2221. proc {half-openInterval} {} { delimitObject "(" "\]•" }
  2222. proc {half-closedInterval} {} { delimitObject "\[" ")•" }
  2223. proc bigParentheses {} { delimitObject "\\left(" "\\right)•" }
  2224. proc bigBrackets {} { delimitObject "\\left\[" "\\right\]•" }
  2225. proc bigBraces {} { delimitObject "\\left\\\{" "\\right\\\}•" }
  2226. proc bigAbsoluteValue {} { delimitObject "\\left|" "\\right|•" }
  2227. proc otherBigDelims {} {
  2228.     set delims [getDelims]
  2229.     if {$delims != ""} then {
  2230.         append leftDelim "\\left" [lindex $delims 0]
  2231.         append rightDelim "\\right" [lindex $delims 1]
  2232.         delimitObject "$leftDelim" "$rightDelim•"
  2233.     }
  2234. }
  2235. proc bigLeftBrace {} { delimitObject "\\left\\\{" "\\right.•" }
  2236. proc otherMixedBigDelims {} {
  2237.     catch {prompt "Choose LEFT delimiter:" "parenthesis" "" "parenthesis" \
  2238.                   "bracket" "brace" "vertical bar" "double bar" \
  2239.                   "angle bracket" "ceiling" "floor" "slash" "backslash" \
  2240.                   "none"} delimType
  2241.     if {$delimType != "cancel"} then {
  2242.         case $delimType in {
  2243.             "parenthesis" {set leftDelim "("}
  2244.             "bracket" {set leftDelim "\["}
  2245.             "brace" {set leftDelim "\\\{"}
  2246.             "{vertical bar}" {set leftDelim "|"}
  2247.             "{double bar}" {set leftDelim "\\|"}
  2248.             "{angle bracket}" {set leftDelim "\\langle"}
  2249.             "ceiling" {set leftDelim "\\lceil"}
  2250.             "floor" {set leftDelim "\\lfloor"}
  2251.             "slash" {set leftDelim "/"}
  2252.             "backslash" {set leftDelim "\\backslash"}
  2253.             "none" {set leftDelim "."}
  2254.             default {
  2255.                 alertnote "\"$delimType\" not recognized"
  2256.                 return
  2257.             }
  2258.         }
  2259.         catch {prompt "Choose RIGHT delimiter:" "parenthesis" "" "parenthesis" \
  2260.                       "bracket" "brace" "vertical bar" "double bar" \
  2261.                       "angle bracket" "ceiling" "floor" "slash" "backslash" \
  2262.                       "none"} delimType
  2263.         if {$delimType != "cancel"} then {
  2264.             case $delimType in {
  2265.                 "parenthesis" {set rightDelim ")"}
  2266.                 "bracket" {set rightDelim "\]"}
  2267.                 "brace" {set rightDelim "\\\}"}
  2268.                 "{vertical bar}" {set rightDelim "|"}
  2269.                 "{double bar}" {set rightDelim "\\|"}
  2270.                 "{angle bracket}" {set rightDelim "\\rangle"}
  2271.                 "ceiling" {set rightDelim "\\rceil"}
  2272.                 "floor" {set rightDelim "\\rfloor"}
  2273.                 "slash" {set rightDelim "/"}
  2274.                 "backslash" {set rightDelim "\\backslash"}
  2275.                 "none" {set rightDelim "."}
  2276.                 default {
  2277.                     alertnote "\"$delimType\" not recognized"
  2278.                     return
  2279.                 }
  2280.             }
  2281.             delimitObject "\\left$leftDelim" "\\right$rightDelim•"
  2282.         }
  2283.     }
  2284. }
  2285.  
  2286. #--------------------------------------------------------------------------
  2287. # Accents:
  2288. #--------------------------------------------------------------------------
  2289.  
  2290. proc acute {} {
  2291.     if {[isSelection] > 1} then {
  2292.         alertnote "Warning: only a single character may be accented!"
  2293.     }
  2294.     if {[wrapObject "\\acute{" "}•"]} then {
  2295.         message "accent set"
  2296.     } else {
  2297.         message "enter one character"
  2298.     }
  2299. }
  2300. proc bar {} {
  2301.     if {[isSelection] > 1} then {
  2302.         alertnote "Warning: only a single character may be accented!"
  2303.     }
  2304.     if {[wrapObject "\\bar{" "}•"]} then {
  2305.         message "accent set"
  2306.     } else {
  2307.         message "enter one character"
  2308.     }
  2309. }
  2310. proc breve {} {
  2311.     if {[isSelection] > 1} then {
  2312.         alertnote "Warning: only a single character may be accented!"
  2313.     }
  2314.     if {[wrapObject "\\breve{" "}•"]} then {
  2315.         message "accent set"
  2316.     } else {
  2317.         message "enter one character"
  2318.     }
  2319. }
  2320. proc check {} {
  2321.     if {[isSelection] > 1} then {
  2322.         alertnote "Warning: only a single character may be accented!"
  2323.     }
  2324.     if {[wrapObject "\\check{" "}•"]} then {
  2325.         message "accent set"
  2326.     } else {
  2327.         message "enter one character"
  2328.     }
  2329. }
  2330. proc dot {} {
  2331.     if {[isSelection] > 1} then {
  2332.         alertnote "Warning: only a single character may be accented!"
  2333.     }
  2334.     if {[wrapObject "\\dot{" "}•"]} then {
  2335.         message "accent set"
  2336.     } else {
  2337.         message "enter one character"
  2338.     }
  2339. }
  2340. proc ddot {} {
  2341.     if {[isSelection] > 1} then {
  2342.         alertnote "Warning: only a single character may be accented!"
  2343.     }
  2344.     if {[wrapObject "\\ddot{" "}•"]} then {
  2345.         message "accent set"
  2346.     } else {
  2347.         message "enter one character"
  2348.     }
  2349. }
  2350. proc grave {} {
  2351.     if {[isSelection] > 1} then {
  2352.         alertnote "Warning: only a single character may be accented!"
  2353.     }
  2354.     if {[wrapObject "\\grave{" "}•"]} then {
  2355.         message "accent set"
  2356.     } else {
  2357.         message "enter one character"
  2358.     }
  2359. }
  2360. proc hat {} {
  2361.     if {[isSelection] > 1} then {
  2362.         alertnote "Warning: only a single character may be accented!"
  2363.     }
  2364.     if {[wrapObject "\\hat{" "}•"]} then {
  2365.         message "accent set"
  2366.     } else {
  2367.         message "enter one character"
  2368.     }
  2369. }
  2370. proc tilde {} {
  2371.     if {[isSelection] > 1} then {
  2372.         alertnote "Warning: only a single character may be accented!"
  2373.     }
  2374.     if {[wrapObject "\\tilde{" "}•"]} then {
  2375.         message "accent set"
  2376.     } else {
  2377.         message "enter one character"
  2378.     }
  2379. }
  2380. proc vec {} {
  2381.     if {[isSelection] > 1} then {
  2382.         alertnote "Warning: only a single character may be accented!"
  2383.     }
  2384.     if {[wrapObject "\\vec{" "}•"]} then {
  2385.         message "accent set"
  2386.     } else {
  2387.         message "enter one character"
  2388.     }
  2389. }
  2390.  
  2391. proc widehat {} {
  2392.     if {[isSelection] > 3} then {
  2393.         alertnote "Warning: only a few characters may be accented!"
  2394.     }
  2395.     if {[wrapObject "\\widehat{" "}•"]} then {
  2396.         message "accent set"
  2397.     } else {
  2398.         message "enter a few characters"
  2399.     }
  2400. }
  2401. proc widetilde {} {
  2402.     if {[isSelection] > 3} then {
  2403.         alertnote "Warning: only a few characters may be accented!"
  2404.     }
  2405.     if {[wrapObject "\\widetilde{" "}•"]} then {
  2406.         message "accent set"
  2407.     } else {
  2408.         message "enter a few characters"
  2409.     }
  2410. }
  2411.  
  2412. proc imath {} {insertObject "\\imath"}
  2413. proc jmath {} {insertObject "\\jmath"}
  2414.  
  2415. #--------------------------------------------------------------------------
  2416. # Grouping:
  2417. #--------------------------------------------------------------------------
  2418.  
  2419. proc underline {} {
  2420.     if {[wrapObject "\\underline{" "}•"]} then {
  2421.         message "selection underlined"
  2422.     } else {
  2423.         message "enter text"
  2424.     }
  2425. }
  2426. proc overline {} {
  2427.     if {[wrapObject "\\overline{" "}•"]} then {
  2428.         message "selection overlined"
  2429.     } else {
  2430.         message "enter text"
  2431.     }
  2432. }
  2433. proc underbrace {} {
  2434.     if {[wrapObject "\\underbrace{" "}•"]} then {
  2435.         message "selection underbraced"
  2436.     } else {
  2437.         message "enter text"
  2438.     }
  2439. }
  2440. proc overbrace {} {
  2441.     if {[wrapObject "\\overbrace{" "}•"]} then {
  2442.         message "selection overbraced"
  2443.     } else {
  2444.         message "enter text"
  2445.     }
  2446. }
  2447. proc stackrel {} {
  2448.     set currentPos [getPos]
  2449.     if {[insertObject "\\stackrel{•}{•}•"]} then {
  2450.         goto $currentPos
  2451.         nextTabStop
  2452.         message "1st arg scriptstyle"
  2453.     }
  2454. }
  2455.  
  2456. #--------------------------------------------------------------------------
  2457. # Spacing:
  2458. #--------------------------------------------------------------------------
  2459.  
  2460. proc negThin {} {insertObject "\\!"}
  2461. proc thin {} {insertObject "\\,"}
  2462. proc medium {} {insertObject "\\:"}
  2463. proc thick {} {insertObject "\\;"}
  2464. proc quad {} {insertObject "\\quad"}
  2465. proc qquad {} {insertObject "\\qquad"}
  2466. proc hspace {} {
  2467.     if {[wrapObject "\\hspace{" "}•"]} then {
  2468.         message "spacing set"
  2469.     } else {
  2470.         message "enter the desired horizontal spacing"
  2471.     }
  2472. }
  2473. proc vspace {} {
  2474.     if {[wrapObject "\\vspace{" "}•"]} then {
  2475.         message "spacing set"
  2476.     } else {
  2477.         message "enter the desired horizontal spacing"
  2478.     }
  2479. }
  2480. proc hfill {} {insertObject "\\hfill"}
  2481. proc vfill {} {insertObject "\\vfill"}
  2482. proc smallskip {} {insertObject "\\smallskip"}
  2483. proc medskip {} {insertObject "\\medskip"}
  2484. proc bigskip {} {insertObject "\\bigskip"}
  2485.  
  2486.  
  2487. #############################################################################
  2488. #
  2489. # LaTeX Menu Definition
  2490. #
  2491. # (see file "latexMenu.tcl")
  2492. #
  2493. #############################################################################
  2494.  
  2495. source "$HOME:Tcl:SystemCode:latexMenu.tcl"
  2496. buildLaTeXMenu
  2497.  
  2498.  
  2499. #############################################################################
  2500. #
  2501. # Special LaTeX Key Bindings
  2502. #
  2503. # (see file "latexKeys.tcl")
  2504. #
  2505. #############################################################################
  2506.  
  2507. source "$HOME:Tcl:SystemCode:latexKeys.tcl"
  2508. bindLaTeXKeys
  2509.  
  2510.